#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>

using namespace std;


const int basesize=1024;
const int argvnum=64;
const int envnum=64;

//全局的命令行参数表
char* gargv[argvnum];
int gargc=0;


int lastcode=0;

//我的系统的环境变量
char* genv[envnum];

// 全局的当前shell工作路径
char pwd[basesize];
char pwdenv[basesize];

//全局变量与重定向有关
#define NoneRedir 0;
#define InputRedir 1;
#define OutputRedir 2;
#define AppRedir 3;

int redir=NoneRedir;
char* filename=nullptr;

#define TrimSpace(pos) do{\
    while(isspace(*pos)){\
        pos++;\
    }\
}while(0)

//  \为续行符
string GetUserName()
{
    char* name=getenv("USER");
    return name==nullptr? "None":string(name);
}

string GetHostName()
{
    char* hostname=getenv("HOSTNAME");
    return hostname==nullptr? "None":string(hostname);
}

string GetPwd()
{
    //环境变量需要我们自己进行维护
    // char* pwd=getenv("PWD");
    // return pwd==nullptr? "None":string(pwd);
    if(nullptr==getcwd(pwd,sizeof(pwd))) return "None";
    snprintf(pwdenv,sizeof(pwdenv),"PWD=%s",pwd);
    putenv(pwdenv);
    return pwd;
}

string LastDir()
{
    string curr=GetPwd();
    if(curr=="/" || curr=="None") return curr;
    size_t pos=curr.rfind("/");
    if(pos==string::npos) return curr;
    return curr.substr(pos+1);
}

string MakeCommandLine()
{
    //mjwl@hcss-ecs-9e43:~/code/lesson5$ -ubuntu
    //[mjwl@hcss-ecs-9e43 lesson5]$  -centos
    char command_line[basesize];
    snprintf(command_line,basesize,"[%s@%s %s]# ",\
        GetUserName().c_str(),GetHostName().c_str(),LastDir().c_str());
    return command_line;
}

void PrintCommandLine()
{
    printf("%s",MakeCommandLine().c_str());
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[],int size)
{
    //拿到一个完整的字符串 ls -a -n
    char* result=fgets(command_buffer,size,stdin);
    if(!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer)-1]=0;//去掉最后按下的回车字符
    if(strlen(command_buffer)==0) return false;
    return true;
}

void ResetCommandLine()
{
    //形成argv数组
    memset(gargv,0,sizeof(gargv));//每次解析前先清空argv数组
    gargc=0;

    //重定向
    redir=NoneRedir;
    filename=nullptr;
}

void ParseRedir(char command_buffer[],int len)
{
    //"ls -a -n"
    //"ls -a -n"< file.txt
    //"ls -a -n"> file.txt
    //"ls -a -n">>file.txt
    int end=len-1;
    while(end>=0)
    {
        if(command_buffer[end]=='<')
        {
            redir=InputRedir;//输入重定向
            filename=&command_buffer[end]+1;
            TrimSpace(filename);
            command_buffer[end]=0;//前面的命令部分
            break;
        }
        else if(command_buffer[end]=='>')
        {
            if(command_buffer[end-1]=='>')
            {
                redir=AppRedir;
                command_buffer[end]=0;
                command_buffer[end-1]=0;
                filename=&command_buffer[end]+1;
                TrimSpace(filename);
                break; 
            }
            else
            {
                redir=OutputRedir;
                command_buffer[end]=0;
                filename=&command_buffer[end]+1;
                TrimSpace(filename);
                break;
            }
        }
        else
        {
            --end;
        }
    }

}

void ParseCommand(char command_buffer[])
{
    const char* sep=" ";
    gargv[gargc++]=strtok(command_buffer,sep);
    while(gargv[gargc++]=strtok(nullptr,sep));
    gargc--;
}

void ParseCommandLine(char command_buffer[],int len)
{
    ResetCommandLine();
    ParseRedir(command_buffer,len);
    ParseCommand(command_buffer);
}

void debug()
{
    printf("argc:%d\n",gargc);
    for(int i=0;gargv[i];++i)
    {
        printf("argv[%d]:%s\n",i,gargv[i]);
    }
}

void DoRedir()
{
    // 1. 重定向应该让子进程自己做！
    // 2. 程序替换会不会影响重定向?不会
    // 0. 先判断 && 重定向

    if(redir == InputRedir)
    {
        //输入重定向
        if(filename)
        {
            int fd=open(filename,O_RDONLY);
            if(fd<0)
            {
                exit(2);
            }
            dup2(fd,0);
        }
        else
        {
            exit(1);
        }
    }
    else if(redir==OutputRedir)
    {
        //输出重定向
        if(filename)
        {
            int fd=open(filename,O_WRONLY | O_CREAT |O_TRUNC,0666);
            if(fd<0)
            {
                exit(4);
            }
            dup2(fd,1);
        }
        else
        {
            exit(3);
        }
    }
    else if(redir==AppRedir)
    {
        //输出重定向
        if(filename)
        {
            int fd=open(filename,O_WRONLY | O_CREAT |O_APPEND,0666);
            if(fd<0)
            {
                exit(6);
            }
            dup2(fd,1);
        }
        else
        {
            exit(5);
        }
    }
    else
    {
        //没有重定向
    }
}

bool ExecuteCommand()
{
    //让子进程进行执行
    pid_t pid=fork();
    if(pid<0) return false;
    if(pid==0) 
    {
        DoRedir();
        //1.执行命令
        execvpe(gargv[0],gargv,genv);//让子进程继承我自己的环境变量
        //2.退出
        exit(1);
    }
    int status=0;
    pid_t rid=waitpid(pid,&status,0);
    if(rid>0)
    {
        if(WIFEXITED(status))
        {
            lastcode=WEXITSTATUS(status);
        }
        else
        {
            lastcode=100;
        }
        return true;
    }
    return false;
}

void AddEnv(const char* item)
{
    int index = 0;
    while(genv[index])
    {
        index++;
    }

    genv[index] = (char*)malloc(strlen(item)+1);
    strncpy(genv[index], item, strlen(item)+1);
    genv[++index] = nullptr;
}
// 在shell中
// 有些命令，必须由子进程来执行
// 有些命令，不能由子进程执行，要由shell自己执行 --- 内建命令 built command
// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExecBuiltCommand()
{
    if(strcmp(gargv[0],"cd")==0)
    {
        //内建命令
        if(gargc==2)
        {
            chdir(gargv[1]);
            lastcode=0;
        }
        else lastcode=1;
        return true;
    }
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode=0;
        }
        else lastcode=2;
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode=0;
        return true;
    }
    else if(strcmp(gargv[0],"echo")==0)
    {
        if(gargc==2)
        {
            if(gargv[1][0]=='$')
            {
                if(gargv[1][1]=='?')
                {
                    printf("%d\n",lastcode);
                    lastcode=0;
                }
            }
            else
            {
                printf("%s\n",gargv[1]);
            }
        }
        else lastcode=3;
        return true;
    }
    return false;
}


// 作为一个shell，获取环境变量应该从系统的配置来
// 我们今天就直接从父shell中获取环境变量
void InitEnv()
{
    extern char** environ;
    int index=0;
    while(environ[index])
    {
        genv[index]=(char*)malloc(strlen(environ[index])+1);
        strncpy(genv[index],environ[index],strlen(environ[index])+1);
        ++index;
    }
    genv[index]=nullptr;
}
int main()
{
    InitEnv();
    char command_buffer[basesize];
    while(true)
    {
        PrintCommandLine();//1.打印命令行提示符
        // printf("\n");
        // sleep(2);

        if(!GetCommandLine(command_buffer,basesize))//2.获取用户命令
        {
            continue;
        }
        //printf("%s\n",command_buffer);
        //"ls -a -l">"hello.txt"
        //"ls -a -l"<hello.txt
        //"ls -a -l">>"hello.txt"
        ParseCommandLine(command_buffer,strlen(command_buffer));//3.分析命令
        //debug();

        if(CheckAndExecBuiltCommand())
        {
            continue;
        }
        ExecuteCommand();//4.执行命令
    }
    return 0;
}